import 'dart:async';
import 'dart:collection';
import 'package:flutter/cupertino.dart';
import 'package:get/get.dart';
import 'package:collection/collection.dart' as Collection;
import '../../lib_runtime/event_center.dart';
import '../../lib_runtime/logger.dart';
import 'model/class_conversation_mixin.dart';

class ConversationController extends GetxController
    with WidgetsBindingObserver, ClassifyConversationMixin {
  static const imEventIdentifier = '._ConvCtrl';
  static const backRefreshTime = 10 * 60 * 1000; // 在后台待10分钟，回前台刷新

  static const convRefreshServerTime =
      30 * 24 * 60 * 60 * 1000; // 超过30天，从服务端拉一次

  int _unReadCount = 10;

  StreamSubscription<Event>? _eventSub;

  /// 进入后台的时间
  int _enterBackgroundTime = 0;

  int _lastRequestUsersTime = 0;

  bool _convPageVisible = true;

  bool initLoading = true;
  int _lastInitLoadingTime = 0; // 上次initload时间
  Timer? _initLoadOverTimer;

  String? _errorMsg; // 错误信息

  @override
  void onInit() {
    super.onInit();
    WidgetsBinding.instance.addObserver(this);
    // conversationMap = LinkedHashMap.of({});
    // EMClient.getInstance.chatManager.addEventHandler(
    //     imEventIdentifier,
    //     EMChatEventHandler(
    //         onMessagesReceived: _onMessagesReceived,
    //         onConversationsUpdate: () {},
    //         onConversationRead: _onConversationRead,
    //         onMessagesRecalled: _onMessagesRecalled));
    // _eventSub = eventCenter.subscribes([
    //   EventConstant.sendChatMessage,
    //   EventConstant.updateChatMessage
    // ]).listen((event) {
    //   if (event.name == EventConstant.sendChatMessage) {
    //     if (event.data is EMMessage) {
    //       insertOrUpdateMap(event.data).then((value) => update());
    //     }
    //   }
    // });
    // // 注册发送消息回调
    // EMClient.getInstance.chatManager.addMessageEvent(
    //     imEventIdentifier, ChatMessageEvent(onSuccess: _onMessageSendSuccess));
    // // 注册连接回调
    // EMClient.getInstance.addConnectionEventHandler(
    //     imEventIdentifier,
    //     EMConnectionEventHandler(
    //       onConnected: _onImConnected,
    //     ));
  }

  @override
  void onReady() {
    super.onReady();
    // EMClient.getInstance.isConnected().then((value) {
    //   if (value) {
    //     initLoadData();
    //   }
    // });
    // _startInitLoadOverTimer();
  }

  @override
  void onClose() {
    super.onClose();
    // _stopInitLoadOverTimer();
    WidgetsBinding.instance.removeObserver(this);
    _eventSub?.cancel();
    // EMClient.getInstance.chatManager.removeEventHandler(imEventIdentifier);
    // EMClient.getInstance.chatManager.removeMessageEvent(imEventIdentifier);
    // EMClient.getInstance.removeConnectionEventHandler(imEventIdentifier);
  }

  /// 加载所有会话列表
  Future loadAllConversations({bool needServer = false}) async {
    // try {
    //   int begin = DateTime.now().millisecondsSinceEpoch;
    //   List<EMConversation> convs =
    //       await EMClient.getInstance.chatManager.loadAllConversations();
    //   RLog.d(
    //       'loadAllConversations =0= ${DateTime.now().millisecondsSinceEpoch - begin}');
    //   if (convs.isEmpty || needServer) {
    //     // 本地没有，从服务端拉一次
    //     CacheUtil.setInt(CacheKeys.lastLoadConvFromServer, nowTime);
    //     convs =
    //         await EMClient.getInstance.chatManager.getConversationsFromServer();
    //     RLog.d('loadAllConversations =server= ${convs.length}');
    //   }
    //   for (var element in convs) {
    //     RLog.d('EMConversationId:${element.id}');
    //   }

    //   initLoading = false;

    //   if (convs.isNotEmpty) {
    //     int begin1 = DateTime.now().millisecondsSinceEpoch;
    //     Iterable<EMConversation> reversedConvs = convs.reversed;
    //     for (EMConversation conv in reversedConvs) {
    //       ConversationWrapper wrapper = ConversationWrapper(conv);
    //       await wrapper.inflate();
    //       classifyConversation(wrapper);
    //     }
    //     RLog.d(
    //         'loadAllConversations =1= ${DateTime.now().millisecondsSinceEpoch - begin1}');
    //     generateClassifyConvs();
    //     update();
    //     refreshUsers(onlyUsers: true);
    //     _refreshUnReadCount();
    //   } else {
    //     update();
    //   }
    // } catch (e) {
    //   initLoading = false;
    //   if (e is EMError) {
    //     _errorMsg = e.description;
    //   } else {
    //     _errorMsg = T.current!.retry_system_error;
    //   }
    //   update();
    // }
  }

  /// 收到消息
  // void _onMessagesReceived(List<EMMessage> messages) async {
  //   if (messages.isNotEmpty) {
  //     if (messages.length == 1) {
  //       await insertOrUpdateMap(messages.first);
  //     } else {
  //       // 按convid分组
  //       Map<String, List<EMMessage>> msgMap =
  //           Collection.groupBy(messages, (msg) => msg.conversationId ?? '');
  //       for (String convId in msgMap.keys) {
  //         List<EMMessage> msgs = msgMap[convId] ?? [];
  //         if (msgs.isEmpty) continue;
  //         if (msgs.length == 1) {
  //           await insertOrUpdateMap(msgs.first);
  //         } else {
  //           // 相同convid组里，按时间排序
  //           msgs.sortByCompare<int>(
  //               (element) => element.serverTime, (a, b) => a.compareTo(b));
  //           //取最新的时间
  //           await insertOrUpdateMap(msgs.last);
  //         }
  //       }
  //     }
  //     update();
  //     _refreshUnReadCount();
  //   }
  // }

  // void _onMessagesRecalled(List<EMMessage> messages) async {
  //   if (messages.isNotEmpty) {
  //     if (messages.length == 1) {
  //       await _deleteOrUpdateConv(messages.first);
  //     } else {
  //       // 按convid分组
  //       Map<String, List<EMMessage>> msgMap =
  //           Collection.groupBy(messages, (msg) => msg.conversationId ?? '');
  //       for (String convId in msgMap.keys) {
  //         List<EMMessage> msgs = msgMap[convId] ?? [];
  //         if (msgs.isEmpty) continue;
  //         _deleteOrUpdateConv(msgs.first);
  //       }
  //     }
  //     update();
  //     _refreshUnReadCount();
  //   }
}

void _onConversationRead(String from, String to) {
  RLog.d('_onConversationRead === $from===$to');
}

// /// 删除消息，更新会话
// Future<void> _deleteOrUpdateConv(EMMessage msg) async {
//   ConversationClassify classify =
//       getClassifyType(msg.attributes) ?? ConversationClassify.normal();
//   if (conversationMap[classify.type]?.containsKey(msg.conversationId) ??
//       false) {
//     await conversationMap[classify.type]?[msg.conversationId]!.inflate();
//   }
//   if (classify.type != categoryNormal) {
//     conversationMap.update(categoryNormal, (value) {
//       ConversationClassify? convClassify =
//           getClassifyType(value.entries.first.value.latestMsg?.attributes);
//       ConversationWrapper? wrapper = genConversationWrapper(convClassify!);
//       if (wrapper != null) {
//         value[wrapper.it.id] = wrapper;
//       }
//       return value;
//     });
//   }
// }

// int get unReadCount => _unReadCount;

// set unReadCount(int count) {
//   _unReadCount = count;
//   FlutterCommon.ins.setBadgeNumber(count);
//   update([ConvUpdateIds.allUnReadCount]);
// }

/// 刷新所有未读数
// void _refreshUnReadCount() {
//   int num = 0;
//   conversationMap[categoryNormal]?.forEach((key, value) {
//     if (key != currentChatConvId) {
//       num += value.unReadNum;
//     }
//   });
//   unReadCount = num;
// }

// void markConvRead(ConversationWrapper? item,
//     {ConversationClassify? classify}) {
//   if (item == null) return;
//   item.unReadNum = 0;
//   item.it.markAllMessagesAsRead();
//   EMClient.getInstance.chatManager.sendConversationReadAck(item.it.id ?? '');
//   if (classify != null) {
//     updateClassifyConv(classify);
//   }
//   _refreshUnReadCount();
//   update();
// }

// void updateUser(ConversationWrapper? conversation, User? userInfo) {
//   if (conversation != null && userInfo != null) {
//     for (ConversationWrapper item
//         in (conversationMap[conversation.classify.type]?.values ?? [])) {
//       if (item.it.id == conversation.it.id) {
//         item.sender?.clearCurrentChannel();
//         item.sender?.clearOnlineStatus();
//         item.sender?.intimacy = userInfo.intimacyValue;
//         item.sender?.mergeFromProto3Json(userInfo.toProto3Json(),
//             ignoreUnknownFields: true);
//         item.updateSender(item.sender);
//         break;
//       }
//     }
//     update();
//   }
// }

// void deleteMessage(ConversationWrapper? conversation, String msgId) async {
//   if (conversation != null) {
//     for (ConversationWrapper item
//         in conversationMap[conversation.classify.type]!.values) {
//       if (item.it.id == conversation.it.id) {
//         await item.inflate();
//         update();
//         break;
//       }
//     }
//   }
// }

// void removeItem(ConversationWrapper item) {
//   conversationMap[item.classify.type]
//       ?.removeWhere((key, value) => key == item.it.id);
//   update();
//   item.it.deleteAllMessages();
//   EMClient.getInstance.chatManager.deleteConversation(item.it.id);
//   //删除远程的
//   EMClient.getInstance.chatManager.deleteRemoteConversation(item.it.id);
// }

// List<MsgListUserItem> get chatUsers {
//   List<MsgListUserItem> result = [];
//   conversationMap[categoryNormal]?.forEach((key, value) {
//     if (!CusTomMessage.isSystemAccount(key) &&
//         !CusTomMessage.isFolderAccount(key)) {
//       result.add(value.sender!);
//     }
//   });
//   return result;
// }

// void _onMessageSendSuccess(String msgId, EMMessage msg) {
//   ConversationClassify classify =
//       getClassifyType(msg.attributes) ?? ConversationClassify.normal();
//   var conversations = conversationMap[classify.type];
//   if (!(conversations?.containsKey(msg.conversationId) ?? false)) {
//     insertOrUpdateMap(msg).then((value) => update());
//   } else {
//     for (ConversationWrapper item in conversations!.values) {
//       if (item.it.id == msg.conversationId &&
//           (item.latestMsg == null ||
//               item.latestMsg!.serverTime < msg.serverTime)) {
//         insertOrUpdateMap(msg).then((value) => update());
//         break;
//       }
//     }
//   }
// }

// @override
// void didChangeAppLifecycleState(AppLifecycleState state) {
//   // super.didChangeAppLifecycleState(state);
//   // if (state == AppLifecycleState.paused) {
//   //   _enterBackgroundTime = DateTime.now().millisecondsSinceEpoch;
//   // } else if (state == AppLifecycleState.resumed) {
//   //   if (_enterBackgroundTime > 0 &&
//   //       DateTime.now().millisecondsSinceEpoch - _enterBackgroundTime >
//   //           backRefreshTime) {
//   //     loadAllConversations();
//   //   }
//   // }
// }

// Future refreshUsers({bool onlyUsers = false}) async {
//   if (_lastRequestUsersTime > 0 &&
//       nowTime - _lastRequestUsersTime < 60 * 1000) {
//     return;
//   }
//   _lastRequestUsersTime = nowTime;
//   List<String> ids = [];
//   conversationMap[categoryNormal]?.forEach((key, value) {
//     if (!CusTomMessage.isSystemAccount(key) &&
//         !CusTomMessage.isFolderAccount(key)) {
//       ids.add(key);
//     }
//   });

//   if (ids.isEmpty) {
//     return;
//   }

//   final userRsp =
//       await UserApi.instance.getMessagePageUserList(ids.join(','));
//   final userList = userRsp.data?.list;
//   if (userList != null && userList.isNotEmpty) {
//     for (ConversationWrapper conv
//         in conversationMap[categoryNormal]!.values) {
//       if (userList.isEmpty) break;
//       int index =
//           userList.indexWhere((element) => element.emUsername == conv.it.id);
//       if (index >= 0) {
//         conv.updateSender(userList.removeAt(index));
//       }
//     }
//     update();
//   }
//   if (!onlyUsers) {
//     eventCenter.emit(Event(EventConstant.refreshFriendPlaying));
//   }
// }

// bool get pageVisible => _convPageVisible;

// set pageVisible(bool visible) {
//   _convPageVisible = visible;
// }

// bool get isInChat =>
//     currentChatConvId != null && currentChatConvId!.isNotEmpty;

// int get nowTime => DateTime.now().millisecondsSinceEpoch;

// // im sdk 连接成功/或者重连成功
// void _onImConnected() {
//   initLoadData();
// }

// get conversations => conversationMap[categoryNormal] ?? {};

// LinkedLruHashMap<String, ConversationWrapper>? classifyConvs(
//         ConversationClassify classify) =>
//     conversationMap[classify.type];

// /// 初始化load，避免短时间内调用多次
// Future initLoadData({bool force = false, bool reset = false}) async {
//   if (!force &&
//       _lastInitLoadingTime > 0 &&
//       nowTime - _lastInitLoadingTime < 5 * 1000) {
//     return;
//   }
//   if (reset) {
//     resetState();
//   }
//   _lastInitLoadingTime = nowTime;
//   _stopInitLoadOverTimer();
//   int lastLoadConvTime = CacheUtil.getInt(CacheKeys.lastLoadConvFromServer);
//   loadAllConversations(
//       needServer: nowTime - lastLoadConvTime > convRefreshServerTime);
// }

// /// 超时还没有connect 回调，主动调一次
// void _startInitLoadOverTimer() {
//   _initLoadOverTimer?.cancel();
//   _initLoadOverTimer = Timer(Duration(seconds: 10), () {
//     initLoadData();
//   });
// }

// void _stopInitLoadOverTimer() {
//   _initLoadOverTimer?.cancel();
//   _initLoadOverTimer = null;
// }

// bool get hasError => _errorMsg != null && _errorMsg!.isNotEmpty;
// String? get errorMsg => _errorMsg;

// void resetState() {
//   _errorMsg = null;
//   initLoading = true;
//   update();
// }
// }

class ConvUpdateIds {
  static const allUnReadCount = 'conv.all.urc';
}
